#pragma once

#include <thread>
#include <memory>
#include <vector>
#include <queue>

#include <rtc_base/slice.h>
#include <json/json.h>

#include "base/event_loop.h"
#include "base/lock_queue.h"
#include "xrtcserver_def.h"
#include  "signaling_server.h"
#include "tcp_connection.h"


namespace xrtc {

class SignalingWorker {
public:
    enum {
        QUIT = 0,
        NEW_CONN = 1,
        RTC_MSG = 2
    };

    // 创建事件循环
    SignalingWorker(int worker_id, const SignalingServerOptions& options);
    ~SignalingWorker();

    int init();
    // 创建工作线程
    bool start();
    // 发送信号通知线程退出
    void stop();
    int notify(int msg);
    void join();

    // 通知线程有新连接
    int notifyNewConn(int fd);
    void pushMsg(std::shared_ptr<RtcMsg> msg);
    std::shared_ptr<RtcMsg> popMsg();
    int sendRtcMsg(std::shared_ptr<RtcMsg> msg);

    // 处理管道写入的回调函数
    friend void signalingWorkerRecvNotify(EventLoop* el, IOWatcher* w, int fd, int events, void* data);
    // 处理连接读/写事件的回调函数
    friend void conn_io_cb(EventLoop*, IOWatcher*, int fd, int events, void* data);
    // 处理连接超时的回调函数
    friend void conn_time_cb(EventLoop* el, TimerWatcher* /*w*/, void* data);

private:
    // 处理管道的各种消息类型通知
    void _processNotify(int msg);
    // 设置新连接的socket配置, 创建TcpConnection对象
    void _newConn(int fd);
    
    // 处理TcpConnection对象的读事件
    void _readQuery(int fd);
    // 处理TcpConnection对象的写事件
    void _write_reply(int fd);

    // 处理请求缓冲区中的消息
    int _processQueryBuffer(TcpConnection* conn);
    // 处理请求头或者请求体
    int _processRequest(TcpConnection* conn,  const rtc::Slice& header, const rtc::Slice& body);
    // 解析推流请求，获取请求参数，向rtcserver的消息队列中投递消息
    int _process_push(int cmdno, TcpConnection* c, const Json::Value& root, uint32_t log_id);
    // 解析answer请求，获取请求参数，向rtcserver的消息队列中投递消息
    int _process_answer(int cmdno, TcpConnection* c, const Json::Value& root, uint32_t log_id);
    // 处理RTCMSG
    void _processRtcMsg();
    // 返回offer消息
    void _responseServerOffer(std::shared_ptr<RtcMsg> msg);
    // 将offer响应包写入tcp连接
    void _add_reply(TcpConnection* conn, const rtc::Slice& reply);

    // 处理tcp连接超时
    void _processTimeout(TcpConnection* conn);
    // 关闭tcp连接
    void _closeConn(TcpConnection* conn);
    // 移除tcp连接对象
    void _removeConn(TcpConnection* conn);

    void _stop();

private:
    int m_worker_id;
    SignalingServerOptions m_options;
    EventLoop* m_el;
    IOWatcher* m_pipe_watcher = nullptr;
    int m_notify_recv_fd = -1;
    int m_notify_send_fd = -1;
    
    std::unique_ptr<std::thread> m_thread;
    ThreadSafeQueue<int> m_lock_queue;

    std::queue<std::shared_ptr<RtcMsg>> m_que_msg;
    std::mutex m_que_msg_mtx;

    std::vector<TcpConnection*> m_connections;
}; 

    
} // namespace xrtc
